/*****************************************Copyright(C)******************************************
****************************************** *********************************************
*------------------------------------------文件信息---------------------------------------------
* FileName          : modbus_master.c
* Author            : 张婷颖
* Version           : 1.0V
* Description       : 
*----------------------------------------历史版本信息-------------------------------------------
* History           :
* Description       :
*-----------------------------------------------------------------------------------------------
***********************************************************************************************/
/* Includes-----------------------------------------------------------------------------------*/
#include "modbus_master.h"
#include "crc16.h"
#include "Bsp_uart.h"
#include "user_protocol.h"
/* Private define-----------------------------------------------------------------------------*/

/* Private typedef----------------------------------------------------------------------------*/

/* Private macro------------------------------------------------------------------------------*/

/* Private variables--------------------------------------------------------------------------*/
uint16_t m_user_crc;                                                     //主站计算CRC
//uint16_t m_ask_crc;                                                    //主站应答CRC

WARPER_ADDR device_read_addr = COIL_GT600_ETHERNET_FAULT;

//INOVANCE_ADDR device_read_addr = DEVICE_STATUS_ADDR;
//INOVANCE_ADDR device_write_addr = LOWER_BEAM_SUM_LENGTH_ADDR_L;

MASTER_STATUS_T master_status;
uint8_t send_count = 0;

uint8_t coil_state[COIL_SIZE];                                          //线圈状态
uint16_t rebuf_into[REGISTER_SIZE];                                     //寄存器    (暂时用做，数据采集缓存区

FRAME_INFO m_recvinfo;                                                 //接收到的信息帧
FRAME_INFO m_txinfo;                                                   //应答信息帧
M_DATA_INFO m_rx_data;                                                  //接收数据域
M_DATA_INFO m_tx_data;                                                  //应答数据域

uint16_t read_buf_len = 0;                                              //已经读取的寄存器数量
uint8_t read_finish = 1;                                                //读取完成标志位
/* Private function prototypes----------------------------------------------------------------*/

/* Private functions--------------------------------------------------------------------------*/
/************************************************
函数名称 ： refresh_info
功    能 ：刷新信息帧，清楚记录
参    数 ：info 发送信息帧或者接收信息帧
返 回 值 ：
*************************************************/
void refresh_info(void)
{
	m_rx_data.buf_header_add = 0;
	m_rx_data.buf_num = 0;
	m_rx_data.data_len = 0;
	m_rx_data.exception_code = NO_ERROR;
	for(int i = 0;i < ONCE_REGISTER_SIZE;i++)
		m_rx_data.buf_rwdata[i]=0;

	m_recvinfo.device_address = 0;
	m_recvinfo.funcode = NO_FUNCODE;
	m_recvinfo.crc_info = 0;

	m_tx_data.buf_header_add = 0;
	m_tx_data.buf_num = 0;
	m_tx_data.data_len = 0;
	m_tx_data.exception_code = NO_ERROR;
	for(int i = 0;i < ONCE_REGISTER_SIZE;i++)
		m_tx_data.buf_rwdata[i]=0;

	m_txinfo.device_address = 0;
	m_txinfo.funcode = NO_FUNCODE;
	m_txinfo.crc_info = 0;
}
/************************************************
函数名称 ： refresh_info
功    能 ：刷新信息帧，清楚记录
参    数 ：info 发送信息帧或者接收信息帧
返 回 值 ：
*************************************************/
void rerequest(void)
{
	send_count++;
	if(send_count <= SEND_MAX)                                            //重发次数未超时，重发，本次请求还未清除，可以直接用
		M_ask_tx_data(m_txinfo,m_tx_data);
	else                                                                  //超出重试次数，放弃请求 本次请求，响应清空，重置重发次数
	{
		master_status = ABANDON_REQUEST;
		refresh_info();
		send_count = 0;
	}

}
/************************************************
函数名称 ： GetFrameInformation
功    能 ：获取接收到帧的信息
参    数 ：pdata 接收到的信息
返 回 值 ： 
*************************************************/
static void M_GetFrameInformation(uint8_t *pdata,uint8_t len)
{
	m_recvinfo.device_address = *(pdata + 0);                            //从站地址
	m_recvinfo.funcode = *(pdata + 1);                                   //功能码
	m_recvinfo.pdata = pdata+2;                                          //指向具体数据
	m_recvinfo.crc_info = (*(pdata + len - 2)<<8)|(*(pdata + len - 1));  //CRC校验值  最后2位
}
/************************************************
函数名称 ： M_Analyse_info
功    能 ： 分析接收到的信息帧
参    数 ： p 接收缓存首地址   len  接收数据长度
返 回 值 ： 无
*************************************************/
uint8_t M_Analyse_info(uint8_t *p,uint8_t Len)
{

	if(Len<FIXEDLEN)                                                             //不足一帧数据最小长度,返回0
		return 0;
	M_GetFrameInformation(p,Len);                                                //获取信息帧内容

	if(m_recvinfo.device_address == MY_ADDRESS_WARPER)                                  //设备地址对应
	{
		m_user_crc = Computer_CRC16(p,Len - 2);                                  //计算CRC（功能码0-6）
		if(m_user_crc == m_recvinfo.crc_info)                                    //crc校验成功
		{
			M_Dealwith(m_recvinfo.pdata);                                      //获取接收数据域中的内容  处理对应功能码及应答

			return 1;
		}
		else
			return 0;
	}
	else
		return 0;

}
/************************************************
函数名称 ： M_Dealwith
功    能 ： 获取接收域数据域中的信息   线圈/寄存器地址  数量  数据    处理对应功能号及应答
参    数 ： codeid功能码
返 回 值 ： 无
*************************************************/
void M_Dealwith(uint8_t *pdata)
{
	switch(m_recvinfo.funcode)
	{
	   //功能码1-4 读取线圈寄存器
		case(FUNCODE_01):
		case(FUNCODE_02):m_rx_data.data_len = *(pdata + 0);			                         //读取的寄存器数据字节数
				   for(int i = 0;i < m_rx_data.data_len;i++)                                 //读取寄存器的数据
					   m_rx_data.buf_rwdata[i] = *(pdata + i + 1);

				   if(M_check_code01_02())                                                 //返回错误，重发请求
				   {
					   rerequest();
				   }
				   else
				   {
					   master_status = FINISH;                                               //本次请求完成
					   refresh_info();                                                       //清除本次请求 响应
					   send_count = 0;                                                       //从站信息正常，清除重发次数
				   }
				   break;
		case(FUNCODE_03):
		case(FUNCODE_04):m_rx_data.data_len = *(pdata + 0);			                         //读取的寄存器数据字节数
				   for(int i = 0;i < m_rx_data.data_len/2;i++)                               //读取寄存器的数据
					   m_rx_data.buf_rwdata[i] = (*(pdata + 1 + i*2)<<8)|(*(pdata + 1 + i*2 + 1));

				   if(M_check_code03_04())                                                 //返回错误，重发请求
				   {
					   rerequest();
				   }
				   else
				   {
					   master_status = FINISH;                                               //本次请求完成
					   refresh_info();                                                       //清除本次请求 响应
					   send_count = 0;                                                       //从站信息正常，清除重发次数
				   }
				   break;

	   //功能码5，6 写入线圈/寄存器   写单个
		case(FUNCODE_05):
		case(FUNCODE_06):m_rx_data.buf_header_add = (*(pdata + 0)<<8)|(*(pdata + 1));         //寄存器首地址
				   m_rx_data.buf_num = 1;                                                     //寄存器数量
				   m_rx_data.buf_rwdata[0] = (*(pdata + 2)<<8)|(*(pdata + 3));                //主站写入的线圈/寄存器的数据

				   if(M_check_code05_06())                                                 //返回错误，重发请求
				   {
					   rerequest();
				   }
				   else
				   {
					   master_status = FINISH;                                               //本次请求完成
					   refresh_info();                                                       //清除本次请求 响应
					   send_count = 0;                                                       //从站信息正常，清除重发次数
				   }
				   break;

	   //功能码15，16 写入寄存器  多个
		case(FUNCODE_0F):
		case(FUNCODE_10):m_rx_data.buf_header_add = (*(pdata + 0)<<8)|(*(pdata + 1));         //寄存器首地址
				   m_rx_data.buf_num = (*(pdata + 2)<<8)|(*(pdata + 3));                      //寄存器数量

				   if(M_check_code0f_10())                                                 //返回错误，重发请求
				   {
					   rerequest();
				   }
				   else
				   {
					   master_status = FINISH;                                               //本次请求完成
					   refresh_info();                                                       //清除本次请求 响应
					   send_count = 0;                                                       //从站信息正常，清除重发次数
				   }
				   break;
		case(ERRORCODE_01):
		case(ERRORCODE_02):
		case(ERRORCODE_03):
		case(ERRORCODE_04):
		case(ERRORCODE_05):
		case(ERRORCODE_06):
		case(ERRORCODE_0F):
		case(ERRORCODE_10):m_rx_data.exception_code = *(pdata + 0);                           //异常码
				   M_error_code();
				   break;
		default:   break;
	}
}

/************************************************
函数名称 ： M_check_code01_02
功    能 ： 检查响应 功能码01--读线圈状态   02--读输入状态
参    数 ： 无
返 回 值 ： 0 无错误   1有错误 重发请求
*************************************************/
uint8_t M_check_code01_02(void)
{
	uint8_t num_bit = 0;                                                  //线圈数量对应的字节数
	num_bit = m_tx_data.buf_num/8;
	if(m_tx_data.buf_num % 8)
		num_bit++;

	if(m_rx_data.data_len == num_bit)                                     //检查字节数是否正确
	{
//		for(int j = 0;j < m_rx_data.data_len;j++)                         //读取到的线圈状态(每一位分开存放)放入线圈缓冲区中，从读取线圈起始位置开始
//		{
//			for(int i = 0;i < 8;i++)
//				coil_state[j*8 + m_tx_data.buf_header_add + i] = ((m_rx_data.buf_rwdata[j] << (7-i))&0x00ff) >> 7;
//		}
#if READ_ALL
		if(read_buf_len == 0)
		{
			rebuf_into[0] = 10;                                               //表示线圈
			rebuf_into[1] = COIL_GT600_ETHERNET_FAULT;
			rebuf_into[2] = 88;
			read_buf_len += 3;
		}
		else if(read_buf_len == 14)
		{
			rebuf_into[14] = 10;                                               //表示线圈
			rebuf_into[15] = COIL_FREQUENCY_CONVERSION_CON_FAULT;
			rebuf_into[16] = 3;
			read_buf_len += 3;
		}
		else if(read_buf_len == 18)
		{
			rebuf_into[18] = 10;                                               //表示线圈
			rebuf_into[19] = COIL_EXCESSIVE_POSITION_DEVIATION;
			rebuf_into[20] = 1;
			read_buf_len += 3;
		}
		for(int i = 0;i < m_rx_data.data_len;i++)
			rebuf_into[i + read_buf_len] = m_rx_data.buf_rwdata[i];
		read_buf_len += m_rx_data.data_len;
#endif
		return 0;
	}
	return 1;
}
/************************************************
函数名称 ： M_check_code03_04
功    能 ： 检查响应 功能码03--读保持寄存器   04--读输入寄存器
参    数 ： 无
返 回 值 ： 0 无错误   1有错误 重发请求
*************************************************/
uint8_t M_check_code03_04(void)
{

	if((m_rx_data.data_len / 2) == m_tx_data.buf_num)                                  //检查返回字节数和请求的寄存器数量是否一致 字节数=寄存器数量*2
	{
#if READ_ALL
		if (read_buf_len == 22)
		{
			rebuf_into[22] = 11;                                               //表示寄存器
			rebuf_into[23] = REG_CURRENT_WARP_LEN;
			rebuf_into[24] = 5;
			read_buf_len += 3;
		}
		else if(read_buf_len == 30)
		{
			rebuf_into[30] = 11;                                               //表示寄存器
			rebuf_into[31] = REG_CURRENT_NUM_LINES;
			rebuf_into[32] = 1;
			read_buf_len += 3;
		}
		else if(read_buf_len == 34)
		{
			rebuf_into[34] = 11;                                               //表示寄存器
			rebuf_into[35] = REG_BAR_WIDTH_VALUE;
			rebuf_into[36] = 4;
			read_buf_len += 3;
		}
		else if(read_buf_len == 41)
		{
			rebuf_into[41] = 11;                                               //表示寄存器
			rebuf_into[42] = REG_DISPLACEMENT;
			rebuf_into[43] = 4;
			read_buf_len += 3;
		}
		for(int i = 0;i < m_rx_data.data_len/2;i++)
			rebuf_into[i + read_buf_len] = m_rx_data.buf_rwdata[i];
		read_buf_len += m_tx_data.buf_num;
		if(read_buf_len == 48)
		{
			tran_modbus(rebuf_into,read_buf_len);
			read_buf_len = 0;
		}
//		if (read_buf_len == 0)
//		{
//			rebuf_into[0] = DEVICE_STATUS_ADDR;
//			rebuf_into[1] = 31;
//			read_buf_len += 2;
//		}
//		else if(read_buf_len == 33)
//		{
//			rebuf_into[33] = LOOM_LET_OFF_SERVO_OUT_V;
//			rebuf_into[34] = 4;
//			read_buf_len += 2;
//		}
//		else if(read_buf_len == 39)
//		{
//			rebuf_into[39] = LOWER_BEAM_SUM_LENGTH_ADDR_L;
//			rebuf_into[40] = 79;
//			read_buf_len += 2;
//		}
//		for(int i = 0;i < m_rx_data.data_len/2;i++)
//			rebuf_into[i + read_buf_len] = m_rx_data.buf_rwdata[i];
//		read_buf_len += m_tx_data.buf_num;
//		if(read_buf_len == 120)
//		{
//			tran_modbus(rebuf_into,read_buf_len);
//			read_buf_len = 0;
//		}
#else
		if (read_buf_len == 0)
		{
			rebuf_into[0] = DEVICE_STATUS_ADDR;
			rebuf_into[1] = 6;
			read_buf_len += 2;
		}
		else if(read_buf_len == 8)
		{
			rebuf_into[8] = ROTATE_SPEED_ADDR;
			rebuf_into[9] = 1;
			read_buf_len += 2;
		}
		else if(read_buf_len == 11)
		{
			rebuf_into[11] = DEVICE_STOP_TYPE_ADDR;
			rebuf_into[12] = 1;
			read_buf_len += 2;
		}
		else if(read_buf_len == 14)
		{
			rebuf_into[11] = LOOM_LET_OFF_SERVO_OUT_V;
			rebuf_into[12] = 4;
			read_buf_len += 2;
		}
		for(int i = 0;i < m_rx_data.data_len/2;i++)
			rebuf_into[i + read_buf_len] = m_rx_data.buf_rwdata[i];
		read_buf_len += m_tx_data.buf_num;
		if(read_buf_len == 20)
		{
			tran_modbus(rebuf_into,read_buf_len);
			read_buf_len = 0;
		}
#endif
			//经过汇川程序检测后，清除本次请求和响应
		return 0;
	}
	return 1;
}
/************************************************
函数名称 ： M_check_code05_06
功    能 ： 检查响应 功能码05--写单个线圈状态  功能码06--写单个寄存器状态   检查与发送是否相同
参    数 ： 无
返 回 值 ： 0 无错误   1有错误 重发请求
*************************************************/
uint8_t M_check_code05_06(void)
{
	if(m_rx_data.buf_header_add == m_tx_data.buf_header_add)
	{
		if(m_rx_data.buf_rwdata[0] == m_tx_data.buf_rwdata[0])
		{
			//检验成功，本次请求完成，清除本次的请求和响应
			return 0;
		}
	}
	return 1;
}
/*************************************************
函数名称 ： M_check_code0f
功    能 ： 检查响应 功能码0f--写多个线圈状态  功能码10--写多个寄存器状态  检查与发送是否相同
参    数 ： 无
返 回 值 ： 0 无错误   1有错误 重发请求
*************************************************/
uint8_t M_check_code0f_10(void)
{
	if(m_rx_data.buf_header_add == m_tx_data.buf_header_add)
	{
		if(m_rx_data.buf_num == m_tx_data.buf_num)
		{
			//检验成功，本次请求完成，清除本次的请求和响应
			return 0;
		}
	}
	return 1;
}
/*************************************************
函数名称 ： M_error_code
功    能 ： 异常处理 要不要延时等待什么的
参    数 ： 无
返 回 值 ： 无
*************************************************/
void M_error_code(void)
{
	if ((m_rx_data.exception_code == DEVICE_COF)|
		(m_rx_data.exception_code == DEVICE_BUSY))
	{
		send_count = 0;                                                            //从站信息正常，清除重发次数
		//延长等待，清除计数
		time_count = 0;
	}
	else                                                                           //其他错误，重新请求
		rerequest();
}
/************************************************
函数名称 ： M_ask_tx_data
功    能 ： 请求新数据
参    数 ：请求数据的信息
返 回 值 ： 无
*************************************************/
void M_ask_tx_data(FRAME_INFO tx_info,M_DATA_INFO tx_data_info)
{
	uint8_t askp[40] = {0};                                        //应答缓存    （包含CRC）
	uint8_t i=0;
	askp[i++] = tx_info.device_address;                            //从站地址
	askp[i++] = tx_info.funcode;                                   //功能码
	askp[i++] = tx_data_info.buf_header_add >> 8;                  //寄存器起始位置高字节
	askp[i++] = tx_data_info.buf_header_add;                       //寄存器起始位置低字节
	switch(tx_info.funcode)
	{
		case(FUNCODE_01):
		case(FUNCODE_02):
		case(FUNCODE_03):
		case(FUNCODE_04):
					askp[i++] = tx_data_info.buf_num >> 8;          //读取线圈/寄存器数量高字节
					askp[i++] = tx_data_info.buf_num;               //读取线圈/寄存器数量低字节
					break;
		case(FUNCODE_05):
		case(FUNCODE_06):
					askp[i++] = tx_data_info.buf_rwdata[0] >> 8;     //写入一个线圈/寄存器的高字节
					askp[i++] = tx_data_info.buf_rwdata[0];          //写入一个线圈/寄存器的低字节
					break;
		case(FUNCODE_0F):
					askp[i++] = tx_data_info.buf_num >> 8;           //写入线圈数量
					askp[i++] = tx_data_info.buf_num;
					tx_data_info.data_len = tx_data_info.buf_num / 8;
					if(tx_data_info.buf_num % 8)
						tx_data_info.data_len++;
					askp[i++] = tx_data_info.data_len;               //写入数据字节数 （线圈数量/8 + （线圈数量%8)）
					for(int j = 0;j < tx_data_info.data_len;j++)
						askp[i + j] = tx_data_info.buf_rwdata[j];
					i += tx_data_info.data_len;
					break;
		case(FUNCODE_10):
					askp[i++] = tx_data_info.buf_num >> 8;           //写入寄存器数量
					askp[i++] = tx_data_info.buf_num;
					tx_data_info.data_len = tx_data_info.buf_num * 2;
					askp[i++] = tx_data_info.data_len;               //写入数据字节数(一个数据2字节)  （寄存器数量*2）
					for(int j = 0,a = 0;j < tx_data_info.data_len;j += 2)
					{
						askp[i + j] = tx_data_info.buf_rwdata[a] >> 8;
						askp[i + j + 1] = tx_data_info.buf_rwdata[a];
						a++;
					}
					i += tx_data_info.data_len;
		default:    break;
	}
	Computer_CRC16(askp,i);                                        //计算CRC
	askp[i++] = crcH;                                              //CRC高字节
	askp[i++] = crcL;                                              //CRC低字节
#if RS232_232_1 || MODBUS_232_1
	Send_Data(&huart4,askp,i);                                     //发送
#endif
#if MODBUS_485
	Send_Data(&huart1,askp,i);                                     //发送
#endif
	time_count = 0;                                                //重新响应计时
	master_status = START_REQUEST;                                 //主站状态，开始请求
}
/************************************************
函数名称 ： M_timeout
功    能 ： 响应超时处理函数   1000ms    在已发送请求的情况下查询
参    数 ：
返 回 值 ： 无
*************************************************/
void M_timeout(void)
{
	if(master_status == START_REQUEST)
	{
		if (time_count > 20)                                          //超时
		{
			send_count++;
			if(send_count <= SEND_MAX)                                //重发次数未超时，重发，本次请求还未清除，可以直接用
			{
				M_ask_tx_data(m_txinfo,m_tx_data);
			}
		}
	}

}

/************************************************
函数名称 ： M_achieves_read
功    能 ： modbus主站测试读取       功能码0x01-0x04
参    数 ：funcode 功能码
			buf_add 寄存器/线圈首地址
			num 寄存器/线圈个数
返 回 值 ： 无
*************************************************/
void M_achieves_read(FUNCODE_T funcode,uint16_t buf_add,uint8_t num)
{
	m_txinfo.device_address = MY_ADDRESS_WARPER;
	m_txinfo.funcode = funcode;
	m_tx_data.buf_header_add = buf_add;
	m_tx_data.buf_num = num;
	M_ask_tx_data(m_txinfo,m_tx_data);
}
/************************************************
函数名称 ： M_achieves_write
功    能 ： modbus主站测试写入       功能码5 6 15 16
参    数 ：funcode 功能码
			buf_add 寄存器/线圈首地址
			num 寄存器/线圈个数
			buf 写入数据
返 回 值 ： 无
*************************************************/
void M_achieves_write(FUNCODE_T funcode,uint16_t buf_add,uint8_t num,uint16_t *buf)
{
	m_txinfo.device_address = MY_ADDRESS_WARPER;
	m_tx_data.buf_header_add = buf_add;
	m_txinfo.funcode = funcode;
	m_tx_data.buf_num = num;
	switch (m_txinfo.funcode)
	{
		case FUNCODE_05:
				break;
		case FUNCODE_0F:
				break;
		case FUNCODE_06:
		case FUNCODE_10:
				for(int i = 0;i < m_tx_data.buf_num;i++)
					m_tx_data.buf_rwdata[i] = *(buf + i);
				break;
		default:
			break;
	}
	M_ask_tx_data(m_txinfo,m_tx_data);
}
/************************************************
函数名称 ： test_read
功    能 ： 测试读取
参    数 ：
返 回 值 ： 无
*************************************************/
void test_read(void)
{
#if READ_ALL
	if(read_finish == 0)
		{
			if(device_read_addr == COIL_GT600_ETHERNET_FAULT)
			{
				M_achieves_read(FUNCODE_01,device_read_addr,88);                                   //初次请求，从线圈M421开始读取88个
				device_read_addr = COIL_FREQUENCY_CONVERSION_CON_FAULT;
			}
			if ((master_status == FINISH)|
				(master_status == ABANDON_REQUEST))                                                //当上一次请求完成或放弃，更改请求，发送下一次请求
			{

				if (device_read_addr == COIL_FREQUENCY_CONVERSION_CON_FAULT)                       //读取线圈M5030部分   3个
				{
					M_achieves_read(FUNCODE_01,device_read_addr,3);
					device_read_addr = COIL_EXCESSIVE_POSITION_DEVIATION;
				}
				else if (device_read_addr == COIL_EXCESSIVE_POSITION_DEVIATION)                   //读取线圈M6177部分  1个
				{
					M_achieves_read(FUNCODE_01,device_read_addr,1);
					device_read_addr = REG_CURRENT_WARP_LEN;
				}
				else if (device_read_addr == REG_CURRENT_WARP_LEN)                                 //读取寄存器D1402部分 5个
				{
					M_achieves_read(FUNCODE_03,device_read_addr,5);
					device_read_addr = REG_CURRENT_NUM_LINES;
				}
				else if (device_read_addr == REG_CURRENT_NUM_LINES)                                 //读取寄存器D1425部分 1个
				{
					M_achieves_read(FUNCODE_03,device_read_addr,1);
					device_read_addr = REG_BAR_WIDTH_VALUE;
				}
				else if (device_read_addr == REG_BAR_WIDTH_VALUE)                                  //读取寄存器D1508部分 4个
				{
					M_achieves_read(FUNCODE_03,device_read_addr,4);
					device_read_addr = REG_DISPLACEMENT;
				}
				else if (device_read_addr == REG_DISPLACEMENT)                                  //读取寄存器D1600部分 4个
				{
					M_achieves_read(FUNCODE_03,device_read_addr,4);
					device_read_addr = COIL_GT600_ETHERNET_FAULT;
					read_finish = 1;
				}
			}
		}
//	if(read_finish == 0)
//	{
//		if(device_read_addr == DEVICE_STATUS_ADDR)
//		{
//			M_achieves_read(FUNCODE_03,device_read_addr,31);                                   //初次请求，从0x3000开始读取31个
//			device_read_addr = LOOM_LET_OFF_SERVO_OUT_V;
//		}
//		if ((master_status == FINISH)|
//			(master_status == ABANDON_REQUEST))                                                 //当上一次请求完成或放弃，更改请求，发送下一次请求
//		{
//
//			if (device_read_addr == LOOM_LET_OFF_SERVO_OUT_V)                                   //读取0x3037部分   4个
//			{
//				M_achieves_read(FUNCODE_03,device_read_addr,4);
//				device_read_addr = LOWER_BEAM_SUM_LENGTH_ADDR_L;
//			}
//			else if (device_read_addr == LOWER_BEAM_SUM_LENGTH_ADDR_L)                         //读取0x3400部分   79个
//			{
//				M_achieves_read(FUNCODE_03,device_read_addr,40);
//				device_read_addr = D_BACK_SLITTER_EDGE_STOP_TIME_ADDR;
//			}
//			else if (device_read_addr == D_BACK_SLITTER_EDGE_STOP_TIME_ADDR)                   //读取0x3428部分
//			{
//				M_achieves_read(FUNCODE_03,device_read_addr,39);
//				device_read_addr = DEVICE_STATUS_ADDR;
//				read_finish = 1;
//			}
//		}
//	}
#else
	if(read_finish == 0)
	{
		if(device_read_addr == DEVICE_STATUS_ADDR)
		{
			M_achieves_read(FUNCODE_03,device_read_addr,6);                                   //初次请求，从0x3000开始读取6个 3000-3005
			device_read_addr = ROTATE_SPEED_ADDR;
		}
		if ((master_status == FINISH)|
			(master_status == ABANDON_REQUEST))                                                //当上一次请求完成或放弃，更改请求，发送下一次请求
		{

			if (device_read_addr == ROTATE_SPEED_ADDR)                                         //读取0x300E部分   1个
			{
				M_achieves_read(FUNCODE_03,device_read_addr,1);
				device_read_addr = DEVICE_STOP_TYPE_ADDR;
			}
			else if (device_read_addr == DEVICE_STOP_TYPE_ADDR)                                //读取0x301B部分  1个
			{
				M_achieves_read(FUNCODE_03,device_read_addr,1);
				device_read_addr = LOOM_LET_OFF_SERVO_OUT_V;
			}
			else if (device_read_addr == LOOM_LET_OFF_SERVO_OUT_V)                              //读取0x3037部分   4个
			{
				M_achieves_read(FUNCODE_03,device_read_addr,4);
				device_read_addr = DEVICE_STATUS_ADDR;
				read_finish = 1;
			}
		}
	}


#endif

}
/************************************************
函数名称 ： test_write
功    能 ： 测试写入
参    数 ：
返 回 值 ： 无
*************************************************/
void test_write(void)
{
//	uint16_t aa = 0xFF;
//	if(device_write_addr == LOWER_BEAM_SUM_LENGTH_ADDR_L)
//	{
//		M_achieves_write(FUNCODE_06,device_write_addr,1,&aa);                                   //初次请求，写入一个
//		device_write_addr += 2;
//	}
//	if ((master_status == FINISH)|
//		(master_status == ABANDON_REQUEST))                                                     //当上一次请求完成或放弃，更改请求，发送下一次请求
//	{
//		device_write_addr += 10;
//		if(device_write_addr < CLOTH_FALLING_TIME_ADDR_S )
//			M_achieves_write(FUNCODE_06,device_write_addr,1,&aa);
//	}

//	uint16_t buf[10]={0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA6,0xA8,0xA9};
//	if(device_write_addr == LOWER_BEAM_SUM_LENGTH_ADDR_L)
//	{
//		device_write_addr += 2;
//		M_achieves_write(FUNCODE_10,device_write_addr,10,buf);                                   //初次请求，写入10个
//	}
//	if ((master_status == FINISH)|
//		(master_status == ABANDON_REQUEST))                                                     //当上一次请求完成或放弃，更改请求，发送下一次请求
//	{
//		device_write_addr += 10;
//		if(device_write_addr < CLOTH_FALLING_TIME_ADDR_S )
//			M_achieves_write(FUNCODE_10,device_write_addr,10,buf);
//		else
//		{
//			device_write_addr =  LOWER_BEAM_SUM_LENGTH_ADDR_L;
//			device_write_addr += 2;
//			M_achieves_write(FUNCODE_10,device_write_addr,10,buf);                                   //初次请求，写入10个
//		}
//
//	}
}
